package com.controller;

import java.util.Arrays;
import java.util.Calendar;
import java.util.Date;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

import com.annotation.IgnoreAuth;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.entity.TokenEntity;
import com.entity.UserEntity;
import com.service.TokenService;
import com.service.UserService;
import com.utils.CommonUtil;
import com.utils.MPUtil;
import com.utils.PageUtils;
import com.utils.R;
import com.utils.ValidatorUtils;

/**
 * 登录相关
 *
 * 该类处理用户登录、注册、退出、密码重置以及用户信息的管理操作
 * 包括前端和后端的接口处理。
 *
 */
@RequestMapping("users")
@RestController
public class UserController {

	@Autowired
	private UserService userService;

	@Autowired
	private TokenService tokenService;

	/**
	 * 用户登录接口
	 *
	 * 通过用户名和密码进行登录，成功后返回token
	 * @param username 用户名
	 * @param password 密码
	 * @param captcha 验证码（未实现）
	 * @param request HttpServletRequest
	 * @return 登录结果，成功返回token，失败返回错误信息
	 */
	@IgnoreAuth
	@PostMapping(value = "/login")
	public R login(String username, String password, String captcha, HttpServletRequest request) {
		// 查找用户
		UserEntity user = userService.selectOne(new EntityWrapper<UserEntity>().eq("username", username));
		if (user == null || !user.getPassword().equals(password)) {
			return R.error("账号或密码不正确");
		}
		// 生成token
		String token = tokenService.generateToken(user.getId(), username, "users", user.getRole());
		return R.ok().put("token", token);
	}

	/**
	 * 用户注册接口
	 *
	 * 注册一个新用户
	 * @param user UserEntity 用户对象，包含用户名、密码等信息
	 * @return 注册结果，成功返回OK，失败返回错误信息
	 */
	@IgnoreAuth
	@PostMapping(value = "/register")
	public R register(@RequestBody UserEntity user) {
		// 检查用户名是否已存在
		if (userService.selectOne(new EntityWrapper<UserEntity>().eq("username", user.getUsername())) != null) {
			return R.error("用户已存在");
		}
		// 插入用户数据
		userService.insert(user);
		return R.ok();
	}

	/**
	 * 用户退出接口
	 *
	 * 退出当前用户，销毁session
	 * @param request HttpServletRequest 请求对象
	 * @return 退出结果
	 */
	@GetMapping(value = "logout")
	public R logout(HttpServletRequest request) {
		request.getSession().invalidate();
		return R.ok("退出成功");
	}

	/**
	 * 密码重置接口
	 *
	 * 根据用户名重置密码为"123456"
	 * @param username 用户名
	 * @param request HttpServletRequest 请求对象
	 * @return 密码重置结果
	 */
	@IgnoreAuth
	@RequestMapping(value = "/resetPass")
	public R resetPass(String username, HttpServletRequest request) {
		// 查找用户
		UserEntity user = userService.selectOne(new EntityWrapper<UserEntity>().eq("username", username));
		if (user == null) {
			return R.error("账号不存在");
		}
		// 重置密码
		user.setPassword("123456");
		userService.update(user, null);
		return R.ok("密码已重置为：123456");
	}

	/**
	 * 用户分页列表接口
	 *
	 * 查询用户列表，支持分页
	 * @param params 查询参数
	 * @param user UserEntity 用户对象
	 * @return 用户分页数据
	 */
	@RequestMapping("/page")
	public R page(@RequestParam Map<String, Object> params, UserEntity user) {
		EntityWrapper<UserEntity> ew = new EntityWrapper<UserEntity>();
		PageUtils page = userService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.allLike(ew, user), params), params));
		return R.ok().put("data", page);
	}

	/**
	 * 用户列表接口
	 *
	 * 获取所有用户列表
	 * @param user UserEntity 用户对象
	 * @return 用户列表
	 */
	@RequestMapping("/list")
	public R list(UserEntity user) {
		EntityWrapper<UserEntity> ew = new EntityWrapper<UserEntity>();
		ew.allEq(MPUtil.allEQMapPre(user, "user"));
		return R.ok().put("data", userService.selectListView(ew));
	}

	/**
	 * 用户信息接口
	 *
	 * 查询指定用户信息
	 * @param id 用户ID
	 * @return 用户信息
	 */
	@RequestMapping("/info/{id}")
	public R info(@PathVariable("id") String id) {
		UserEntity user = userService.selectById(id);
		return R.ok().put("data", user);
	}

	/**
	 * 获取当前登录用户信息
	 *
	 * 从session获取当前用户ID，查询并返回该用户信息
	 * @param request HttpServletRequest 请求对象
	 * @return 当前用户信息
	 */
	@RequestMapping("/session")
	public R getCurrUser(HttpServletRequest request) {
		Long id = (Long) request.getSession().getAttribute("userId");
		UserEntity user = userService.selectById(id);
		return R.ok().put("data", user);
	}

	/**
	 * 用户保存接口
	 *
	 * 保存新用户
	 * @param user UserEntity 用户对象
	 * @return 保存结果
	 */
	@PostMapping("/save")
	public R save(@RequestBody UserEntity user) {
		// 检查用户名是否已存在
		if (userService.selectOne(new EntityWrapper<UserEntity>().eq("username", user.getUsername())) != null) {
			return R.error("用户已存在");
		}
		// 插入用户数据
		userService.insert(user);
		return R.ok();
	}

	/**
	 * 用户信息修改接口
	 *
	 * 修改用户信息
	 * @param user UserEntity 用户对象
	 * @return 修改结果
	 */
	@RequestMapping("/update")
	public R update(@RequestBody UserEntity user) {
		// 检查用户名是否已存在
		UserEntity u = userService.selectOne(new EntityWrapper<UserEntity>().eq("username", user.getUsername()));
		if (u != null && u.getId() != user.getId() && u.getUsername().equals(user.getUsername())) {
			return R.error("用户名已存在。");
		}
		// 更新用户信息
		userService.updateById(user); // 全部更新
		return R.ok();
	}

	/**
	 * 用户删除接口
	 *
	 * 删除指定用户
	 * @param ids 用户ID列表
	 * @return 删除结果
	 */
	@RequestMapping("/delete")
	public R delete(@RequestBody Long[] ids) {
		userService.deleteBatchIds(Arrays.asList(ids));
		return R.ok();
	}
}
